home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / modifier.cpp < prev    next >
C/C++ Source or Header  |  1999-05-14  |  42KB  |  1,008 lines
  1. // $Id: modifier.cpp,v 1.5 1999/03/09 14:37:17 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include "semantic.h"
  12.  
  13. AccessFlags Semantic::ProcessClassModifiers(AstClassDeclaration *class_declaration)
  14. {
  15.     AccessFlags access_flags;
  16.  
  17.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  18.     {
  19.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  20.  
  21.         switch(modifier -> kind)
  22.         {
  23.             case Ast::ABSTRACT:
  24.                  if (access_flags.ACC_ABSTRACT())
  25.                  {
  26.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  27.                                     modifier -> modifier_kind_token,
  28.                                     modifier -> modifier_kind_token);
  29.                  }
  30.                  else access_flags.SetACC_ABSTRACT();
  31.  
  32.                  if (access_flags.ACC_FINAL())
  33.                  {
  34.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  35.                                     modifier -> modifier_kind_token,
  36.                                     modifier -> modifier_kind_token);
  37.                  }
  38.                  break;
  39.             case Ast::FINAL:
  40.                  if (access_flags.ACC_FINAL())
  41.                  {
  42.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  43.                                     modifier -> modifier_kind_token,
  44.                                     modifier -> modifier_kind_token);
  45.                  }
  46.                  else access_flags.SetACC_FINAL();
  47.  
  48.                  if (access_flags.ACC_ABSTRACT())
  49.                  {
  50.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  51.                                     modifier -> modifier_kind_token,
  52.                                     modifier -> modifier_kind_token);
  53.                  }
  54.                  break;
  55.             case Ast::PUBLIC:
  56.                  if (access_flags.ACC_PUBLIC())
  57.                  {
  58.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  59.                                     modifier -> modifier_kind_token,
  60.                                     modifier -> modifier_kind_token);
  61.                  }
  62.                  else access_flags.SetACC_PUBLIC();
  63.                  break;
  64.             case Ast::STRICTFP:
  65.                  if (access_flags.ACC_STRICTFP())
  66.                  {
  67.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  68.                                     modifier -> modifier_kind_token,
  69.                                     modifier -> modifier_kind_token);
  70.                  }
  71.                  else access_flags.SetACC_STRICTFP();
  72.                  break;
  73.             default:
  74.                  ReportSemError(SemanticError::INVALID_TOP_LEVEL_CLASS_MODIFIER,
  75.                                 modifier -> modifier_kind_token,
  76.                                 modifier -> modifier_kind_token,
  77.                                 lex_stream -> Name(modifier -> modifier_kind_token));
  78.                  break;
  79.         }
  80.     }
  81.  
  82.     return access_flags;
  83. }
  84.  
  85.  
  86.  
  87. AccessFlags Semantic::ProcessLocalClassModifiers(AstClassDeclaration *class_declaration)
  88. {
  89.     AccessFlags access_flags;
  90.  
  91.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  92.     {
  93.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  94.  
  95.         switch(modifier -> kind)
  96.         {
  97.             case Ast::ABSTRACT:
  98.                  if (access_flags.ACC_ABSTRACT())
  99.                  {
  100.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  101.                                     modifier -> modifier_kind_token,
  102.                                     modifier -> modifier_kind_token);
  103.                  }
  104.                  else access_flags.SetACC_ABSTRACT();
  105.  
  106.                  if (access_flags.ACC_FINAL())
  107.                  {
  108.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  109.                                     modifier -> modifier_kind_token,
  110.                                     modifier -> modifier_kind_token);
  111.                  }
  112.                  break;
  113.             case Ast::FINAL:
  114.                  if (access_flags.ACC_FINAL())
  115.                  {
  116.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  117.                                     modifier -> modifier_kind_token,
  118.                                     modifier -> modifier_kind_token);
  119.                  }
  120.                  else access_flags.SetACC_FINAL();
  121.  
  122.                  if (access_flags.ACC_ABSTRACT())
  123.                  {
  124.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  125.                                     modifier -> modifier_kind_token,
  126.                                     modifier -> modifier_kind_token);
  127.                  }
  128.                  break;
  129.             case Ast::STRICTFP:
  130.                  if (access_flags.ACC_STRICTFP())
  131.                  {
  132.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  133.                                     modifier -> modifier_kind_token,
  134.                                     modifier -> modifier_kind_token);
  135.                  }
  136.                  else access_flags.SetACC_STRICTFP();
  137.                  break;
  138.             default:
  139.                  ReportSemError(SemanticError::INVALID_LOCAL_CLASS_MODIFIER,
  140.                                 modifier -> modifier_kind_token,
  141.                                 modifier -> modifier_kind_token,
  142.                                 lex_stream -> Name(modifier -> modifier_kind_token));
  143.                  break;
  144.         }
  145.     }
  146.  
  147.     return access_flags;
  148. }
  149.  
  150.  
  151. AccessFlags Semantic::ProcessNestedClassModifiers(AstClassDeclaration *class_declaration)
  152. {
  153.     AccessFlags access_flags;
  154.  
  155.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  156.     {
  157.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  158.  
  159.         switch(modifier -> kind)
  160.         {
  161.             case Ast::ABSTRACT:
  162.                  if (access_flags.ACC_ABSTRACT())
  163.                  {
  164.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  165.                                     modifier -> modifier_kind_token,
  166.                                     modifier -> modifier_kind_token);
  167.                  }
  168.                  else access_flags.SetACC_ABSTRACT();
  169.  
  170.                  if (access_flags.ACC_FINAL())
  171.                  {
  172.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  173.                                     modifier -> modifier_kind_token,
  174.                                     modifier -> modifier_kind_token);
  175.                  }
  176.                  break;
  177.             case Ast::FINAL:
  178.                  if (access_flags.ACC_FINAL())
  179.                  {
  180.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  181.                                     modifier -> modifier_kind_token,
  182.                                     modifier -> modifier_kind_token);
  183.                  }
  184.                  else access_flags.SetACC_FINAL();
  185.  
  186.                  if (access_flags.ACC_ABSTRACT())
  187.                  {
  188.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  189.                                     modifier -> modifier_kind_token,
  190.                                     modifier -> modifier_kind_token);
  191.                  }
  192.                  break;
  193.             case Ast::PUBLIC:
  194.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  195.                  {
  196.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  197.                                     modifier -> modifier_kind_token,
  198.                                     modifier -> modifier_kind_token);
  199.                  }
  200.                  else access_flags.SetACC_PUBLIC();
  201.                  break;
  202.             case Ast::PRIVATE:
  203.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.A